package com.hivemc.chunker.conversion.encoding.java.base.resolver.identifier.legacy;

import com.hivemc.chunker.conversion.encoding.base.resolver.identifier.state.TypeMapping;
import com.hivemc.chunker.conversion.intermediate.column.chunk.identifier.type.block.states.BlockStateValue;
import com.hivemc.chunker.conversion.intermediate.column.chunk.identifier.type.block.states.vanilla.types.*;

import java.util.ArrayList;
import java.util.List;

/**
 * A list of types which map how the data values should be converted between legacy Java and Chunker.
 */
public class JavaLegacyStateTypes {
    public static final TypeMapping<Integer, Age_15> AGE_15 = new TypeMapping.Builder<Integer, Age_15>()
            .mapping(0, Age_15._0)
            .mapping(1, Age_15._1)
            .mapping(2, Age_15._2)
            .mapping(3, Age_15._3)
            .mapping(4, Age_15._4)
            .mapping(5, Age_15._5)
            .mapping(6, Age_15._6)
            .mapping(7, Age_15._7)
            .mapping(8, Age_15._8)
            .mapping(9, Age_15._9)
            .mapping(10, Age_15._10)
            .mapping(11, Age_15._11)
            .mapping(12, Age_15._12)
            .mapping(13, Age_15._13)
            .mapping(14, Age_15._14)
            .mapping(15, Age_15._15)
            .build();
    public static final TypeMapping<Integer, Age_3> AGE_3 = new TypeMapping.Builder<Integer, Age_3>()
            .mapping(0, Age_3._0)
            .mapping(1, Age_3._1)
            .mapping(2, Age_3._2)
            .mapping(3, Age_3._3)
            .build();
    public static final TypeMapping<Integer, Age_7> AGE_3_TO_7 = new TypeMapping.Builder<Integer, Age_7>()
            .mapping(0, Age_7._0)
            .mapping(0, Age_7._1)
            .mapping(1, Age_7._2)
            .mapping(1, Age_7._3)
            .mapping(2, Age_7._4)
            .mapping(2, Age_7._5)
            .mapping(2, Age_7._6)
            .mapping(3, Age_7._7)
            .build();
    public static final TypeMapping<Integer, Age_5> AGE_5 = new TypeMapping.Builder<Integer, Age_5>()
            .mapping(0, Age_5._0)
            .mapping(1, Age_5._1)
            .mapping(2, Age_5._2)
            .mapping(3, Age_5._3)
            .mapping(4, Age_5._4)
            .mapping(5, Age_5._5)
            .build();
    public static final TypeMapping<Integer, Age_7> AGE_7 = new TypeMapping.Builder<Integer, Age_7>()
            .mapping(0, Age_7._0)
            .mapping(1, Age_7._1)
            .mapping(2, Age_7._2)
            .mapping(3, Age_7._3)
            .mapping(4, Age_7._4)
            .mapping(5, Age_7._5)
            .mapping(6, Age_7._6)
            .mapping(7, Age_7._7)
            .build();
    public static final TypeMapping<Integer, Axis> AXIS = new TypeMapping.Builder<Integer, Axis>()
            .mapping(0, Axis.Y)
            .mapping(4, Axis.X)
            .mapping(8, Axis.Z)
            .build();
    public static final TypeMapping<Integer, AxisHorizontal> AXIS_HORIZONTAL = new TypeMapping.Builder<Integer, AxisHorizontal>()
            .mapping(1, AxisHorizontal.X)
            .mapping(2, AxisHorizontal.Z)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BED = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(BedPart.FOOT, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(1, List.of(BedPart.FOOT, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(2, List.of(BedPart.FOOT, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(3, List.of(BedPart.FOOT, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(8, List.of(BedPart.HEAD, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(9, List.of(BedPart.HEAD, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(10, List.of(BedPart.HEAD, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(11, List.of(BedPart.HEAD, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(12, List.of(BedPart.HEAD, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(13, List.of(BedPart.HEAD, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(14, List.of(BedPart.HEAD, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(15, List.of(BedPart.HEAD, FacingDirectionHorizontal.EAST, Bool.TRUE))
            // Duplicates, mapping to the foot part (the occupied bool isn't stored in the foot)
            .mapping(0, List.of(BedPart.FOOT, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(1, List.of(BedPart.FOOT, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(2, List.of(BedPart.FOOT, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(3, List.of(BedPart.FOOT, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, Bites> BITES = new TypeMapping.Builder<Integer, Bites>()
            .mapping(0, Bites._0)
            .mapping(1, Bites._1)
            .mapping(2, Bites._2)
            .mapping(3, Bites._3)
            .mapping(4, Bites._4)
            .mapping(5, Bites._5)
            .mapping(6, Bites._6)
            .build();
    public static final TypeMapping<Integer, Bool> BOOL = new TypeMapping.Builder<Integer, Bool>()
            .mapping(0, Bool.FALSE)
            .mapping(1, Bool.TRUE)
            .build();
    public static final TypeMapping<Integer, Bool> BOOLS_TO_VINE_DIRECTION = new TypeMapping.Builder<Integer, Bool>()
            .generate((builder) -> {
                // Convert south, west, north, east into an integer
                for (int input = 0; input < 16; input++) {
                    List<Bool> output = new ArrayList<>(4);
                    for (int j = 0; j < 4; j++) {
                        output.add(((input >> j) & 1) == 1 ? Bool.TRUE : Bool.FALSE);
                    }
                    builder.mapping(input, output);
                }
            })
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BOOL_FACING_ALL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, FacingDirection.DOWN))
            .mapping(1, List.of(Bool.FALSE, FacingDirection.UP))
            .mapping(2, List.of(Bool.FALSE, FacingDirection.NORTH))
            .mapping(3, List.of(Bool.FALSE, FacingDirection.SOUTH))
            .mapping(4, List.of(Bool.FALSE, FacingDirection.WEST))
            .mapping(5, List.of(Bool.FALSE, FacingDirection.EAST))
            .mapping(8, List.of(Bool.TRUE, FacingDirection.DOWN))
            .mapping(9, List.of(Bool.TRUE, FacingDirection.UP))
            .mapping(10, List.of(Bool.TRUE, FacingDirection.NORTH))
            .mapping(11, List.of(Bool.TRUE, FacingDirection.SOUTH))
            .mapping(12, List.of(Bool.TRUE, FacingDirection.WEST))
            .mapping(13, List.of(Bool.TRUE, FacingDirection.EAST))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BOOL_FACING_HORIZONTAL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(1, List.of(Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(2, List.of(Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(3, List.of(Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(4, List.of(Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(5, List.of(Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(6, List.of(Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(7, List.of(Bool.TRUE, FacingDirectionHorizontal.EAST))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BREWING_STAND = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(2, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(5, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(7, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BUTTON = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(0, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(1, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(2, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(3, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(4, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(5, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(5, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(8, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(8, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(9, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(10, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(11, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(12, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(13, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(13, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            // Duplicate states which aren't supported (mapped to closest)
            .mapping(0, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(0, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(8, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(8, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(5, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(5, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(13, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(13, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .build();
    public static final TypeMapping<Integer, CauldronLevel> CAULDRON_LEVEL = new TypeMapping.Builder<Integer, CauldronLevel>()
            // Java only has 3 states for cauldron level
            .mapping(1, CauldronLevel._2)
            .mapping(1, CauldronLevel._1)
            .mapping(2, CauldronLevel._4)
            .mapping(2, CauldronLevel._3)
            .mapping(3, CauldronLevel._6)
            .mapping(3, CauldronLevel._5)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> COCOA = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.SOUTH, Age_2._0))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, Age_2._0))
            .mapping(2, List.of(FacingDirectionHorizontal.NORTH, Age_2._0))
            .mapping(3, List.of(FacingDirectionHorizontal.EAST, Age_2._0))
            .mapping(4, List.of(FacingDirectionHorizontal.SOUTH, Age_2._1))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, Age_2._1))
            .mapping(6, List.of(FacingDirectionHorizontal.NORTH, Age_2._1))
            .mapping(7, List.of(FacingDirectionHorizontal.EAST, Age_2._1))
            .mapping(8, List.of(FacingDirectionHorizontal.SOUTH, Age_2._2))
            .mapping(9, List.of(FacingDirectionHorizontal.WEST, Age_2._2))
            .mapping(10, List.of(FacingDirectionHorizontal.NORTH, Age_2._2))
            .mapping(11, List.of(FacingDirectionHorizontal.EAST, Age_2._2))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> DOOR = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(12, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(13, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(14, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(15, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            // Duplicate states which aren't supported
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(0, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(0, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(0, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> DOOR_2 = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            // Duplicate states which aren't supported
            .mapping(0, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.RIGHT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(0, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(0, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.LEFT, Half.BOTTOM, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, FacingDirection> FACING_DIRECTION = new TypeMapping.Builder<Integer, FacingDirection>()
            .mapping(0, FacingDirection.DOWN)
            .mapping(1, FacingDirection.UP)
            .mapping(2, FacingDirection.NORTH)
            .mapping(3, FacingDirection.SOUTH)
            .mapping(4, FacingDirection.WEST)
            .mapping(5, FacingDirection.EAST)
            .build();
    public static final TypeMapping<Integer, FacingDirectionHorizontal> FACING_HORIZONTAL_SWNE = new TypeMapping.Builder<Integer, FacingDirectionHorizontal>()
            .mapping(0, FacingDirectionHorizontal.SOUTH)
            .mapping(1, FacingDirectionHorizontal.WEST)
            .mapping(3, FacingDirectionHorizontal.EAST)
            .mapping(2, FacingDirectionHorizontal.NORTH)
            .build();
    public static final TypeMapping<Integer, FacingDirectionHorizontal> FACING_HORIZONTAL_UNUSUAL = new TypeMapping.Builder<Integer, FacingDirectionHorizontal>()
            .mapping(2, FacingDirectionHorizontal.NORTH)
            .mapping(3, FacingDirectionHorizontal.SOUTH)
            .mapping(4, FacingDirectionHorizontal.WEST)
            .mapping(5, FacingDirectionHorizontal.EAST)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> FACING_PISTON = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirection.DOWN, PistonType.NORMAL))
            .mapping(1, List.of(FacingDirection.UP, PistonType.NORMAL))
            .mapping(2, List.of(FacingDirection.NORTH, PistonType.NORMAL))
            .mapping(3, List.of(FacingDirection.SOUTH, PistonType.NORMAL))
            .mapping(4, List.of(FacingDirection.WEST, PistonType.NORMAL))
            .mapping(5, List.of(FacingDirection.EAST, PistonType.NORMAL))
            .mapping(8, List.of(FacingDirection.DOWN, PistonType.STICKY))
            .mapping(9, List.of(FacingDirection.UP, PistonType.STICKY))
            .mapping(10, List.of(FacingDirection.NORTH, PistonType.STICKY))
            .mapping(11, List.of(FacingDirection.SOUTH, PistonType.STICKY))
            .mapping(12, List.of(FacingDirection.WEST, PistonType.STICKY))
            .mapping(13, List.of(FacingDirection.EAST, PistonType.STICKY))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> FENCE_GATE = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(1, List.of(Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(2, List.of(Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(3, List.of(Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(5, List.of(Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(7, List.of(Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(8, List.of(Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(9, List.of(Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(10, List.of(Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(11, List.of(Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(12, List.of(Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(13, List.of(Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(15, List.of(Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> HOPPER = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.TRUE, FacingDirectionHorizontalDown.DOWN))
            .mapping(2, List.of(Bool.TRUE, FacingDirectionHorizontalDown.NORTH))
            .mapping(3, List.of(Bool.TRUE, FacingDirectionHorizontalDown.SOUTH))
            .mapping(4, List.of(Bool.TRUE, FacingDirectionHorizontalDown.WEST))
            .mapping(5, List.of(Bool.TRUE, FacingDirectionHorizontalDown.EAST))
            .mapping(8, List.of(Bool.FALSE, FacingDirectionHorizontalDown.DOWN))
            .mapping(10, List.of(Bool.FALSE, FacingDirectionHorizontalDown.NORTH))
            .mapping(11, List.of(Bool.FALSE, FacingDirectionHorizontalDown.SOUTH))
            .mapping(12, List.of(Bool.FALSE, FacingDirectionHorizontalDown.WEST))
            .mapping(13, List.of(Bool.FALSE, FacingDirectionHorizontalDown.EAST))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> LEVER = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(0, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(1, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(2, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(3, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(4, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(5, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(5, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(6, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(6, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(7, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(7, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(8, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(8, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(9, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(10, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(11, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(12, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(13, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(13, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(14, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(14, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(15, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(15, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .build();
    public static final TypeMapping<Integer, LiquidLevel> LIQUID_LEVEL = new TypeMapping.Builder<Integer, LiquidLevel>()
            .mapping(0, LiquidLevel._0)
            .mapping(1, LiquidLevel._1)
            .mapping(2, LiquidLevel._2)
            .mapping(3, LiquidLevel._3)
            .mapping(4, LiquidLevel._4)
            .mapping(5, LiquidLevel._5)
            .mapping(6, LiquidLevel._6)
            .mapping(7, LiquidLevel._7)
            .mapping(8, LiquidLevel._8)
            .mapping(9, LiquidLevel._9)
            .mapping(10, LiquidLevel._10)
            .mapping(11, LiquidLevel._11)
            .mapping(12, LiquidLevel._12)
            .mapping(13, LiquidLevel._13)
            .mapping(14, LiquidLevel._14)
            .mapping(15, LiquidLevel._15)
            .build();
    public static final TypeMapping<Integer, Moisture> MOISTURE = new TypeMapping.Builder<Integer, Moisture>()
            .mapping(0, Moisture._0)
            .mapping(1, Moisture._1)
            .mapping(2, Moisture._2)
            .mapping(3, Moisture._3)
            .mapping(4, Moisture._4)
            .mapping(5, Moisture._5)
            .mapping(6, Moisture._6)
            .mapping(7, Moisture._7)
            .build();
    public static final TypeMapping<Integer, Bool> MUSHROOM_FACE_BITS = new TypeMapping.Builder<Integer, Bool>()
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(2, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(7, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(8, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(5, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(0, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(2, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(2, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(2, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(0, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(7, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(7, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(7, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(8, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(8, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(8, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            // Pores only
            .mapping(13, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(12, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(11, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .build();
    public static final TypeMapping<Integer, Power> POWER = new TypeMapping.Builder<Integer, Power>()
            .mapping(0, Power._0)
            .mapping(1, Power._1)
            .mapping(2, Power._2)
            .mapping(3, Power._3)
            .mapping(4, Power._4)
            .mapping(5, Power._5)
            .mapping(6, Power._6)
            .mapping(7, Power._7)
            .mapping(8, Power._8)
            .mapping(9, Power._9)
            .mapping(10, Power._10)
            .mapping(11, Power._11)
            .mapping(12, Power._12)
            .mapping(13, Power._13)
            .mapping(14, Power._14)
            .mapping(15, Power._15)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> POWERED_COMPARATOR = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(1, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(2, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(3, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(4, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(5, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(6, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(7, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(8, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(9, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(10, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(11, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(12, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(13, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(14, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(15, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> POWERED_RAIL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, RailShapeStraight.NORTH_SOUTH))
            .mapping(1, List.of(Bool.FALSE, RailShapeStraight.EAST_WEST))
            .mapping(2, List.of(Bool.FALSE, RailShapeStraight.ASCENDING_EAST))
            .mapping(3, List.of(Bool.FALSE, RailShapeStraight.ASCENDING_WEST))
            .mapping(4, List.of(Bool.FALSE, RailShapeStraight.ASCENDING_NORTH))
            .mapping(5, List.of(Bool.FALSE, RailShapeStraight.ASCENDING_SOUTH))
            .mapping(8, List.of(Bool.TRUE, RailShapeStraight.NORTH_SOUTH))
            .mapping(9, List.of(Bool.TRUE, RailShapeStraight.EAST_WEST))
            .mapping(10, List.of(Bool.TRUE, RailShapeStraight.ASCENDING_EAST))
            .mapping(11, List.of(Bool.TRUE, RailShapeStraight.ASCENDING_WEST))
            .mapping(12, List.of(Bool.TRUE, RailShapeStraight.ASCENDING_NORTH))
            .mapping(13, List.of(Bool.TRUE, RailShapeStraight.ASCENDING_SOUTH))
            .build();
    public static final TypeMapping<Integer, RailShape> RAIL_SHAPE = new TypeMapping.Builder<Integer, RailShape>()
            .mapping(0, RailShape.NORTH_SOUTH)
            .mapping(1, RailShape.EAST_WEST)
            .mapping(2, RailShape.ASCENDING_EAST)
            .mapping(3, RailShape.ASCENDING_WEST)
            .mapping(4, RailShape.ASCENDING_NORTH)
            .mapping(5, RailShape.ASCENDING_SOUTH)
            .mapping(6, RailShape.SOUTH_EAST)
            .mapping(7, RailShape.SOUTH_WEST)
            .mapping(8, RailShape.NORTH_WEST)
            .mapping(9, RailShape.NORTH_EAST)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> REPEATER = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Delay._1, FacingDirectionHorizontal.SOUTH))
            .mapping(1, List.of(Delay._1, FacingDirectionHorizontal.WEST))
            .mapping(2, List.of(Delay._1, FacingDirectionHorizontal.NORTH))
            .mapping(3, List.of(Delay._1, FacingDirectionHorizontal.EAST))
            .mapping(4, List.of(Delay._2, FacingDirectionHorizontal.SOUTH))
            .mapping(5, List.of(Delay._2, FacingDirectionHorizontal.WEST))
            .mapping(6, List.of(Delay._2, FacingDirectionHorizontal.NORTH))
            .mapping(7, List.of(Delay._2, FacingDirectionHorizontal.EAST))
            .mapping(8, List.of(Delay._3, FacingDirectionHorizontal.SOUTH))
            .mapping(9, List.of(Delay._3, FacingDirectionHorizontal.WEST))
            .mapping(10, List.of(Delay._3, FacingDirectionHorizontal.NORTH))
            .mapping(11, List.of(Delay._3, FacingDirectionHorizontal.EAST))
            .mapping(12, List.of(Delay._4, FacingDirectionHorizontal.SOUTH))
            .mapping(13, List.of(Delay._4, FacingDirectionHorizontal.WEST))
            .mapping(14, List.of(Delay._4, FacingDirectionHorizontal.NORTH))
            .mapping(15, List.of(Delay._4, FacingDirectionHorizontal.EAST))
            .build();
    public static final TypeMapping<Integer, Rotation> ROTATION = new TypeMapping.Builder<Integer, Rotation>()
            .mapping(0, Rotation._0)
            .mapping(1, Rotation._1)
            .mapping(2, Rotation._2)
            .mapping(3, Rotation._3)
            .mapping(4, Rotation._4)
            .mapping(5, Rotation._5)
            .mapping(6, Rotation._6)
            .mapping(7, Rotation._7)
            .mapping(8, Rotation._8)
            .mapping(9, Rotation._9)
            .mapping(10, Rotation._10)
            .mapping(11, Rotation._11)
            .mapping(12, Rotation._12)
            .mapping(13, Rotation._13)
            .mapping(14, Rotation._14)
            .mapping(15, Rotation._15)
            .build();
    public static final TypeMapping<Integer, SlabType> SLAB_TYPE = new TypeMapping.Builder<Integer, SlabType>()
            .mapping(0, SlabType.BOTTOM)
            .mapping(8, SlabType.TOP)
            .invalidOutput(SlabType.DOUBLE) // DOUBLE isn't allowed here
            .build();
    public static final TypeMapping<Integer, Layers> SNOW_LAYERS = new TypeMapping.Builder<Integer, Layers>()
            .mapping(0, Layers._1)
            .mapping(1, Layers._2)
            .mapping(2, Layers._3)
            .mapping(3, Layers._4)
            .mapping(4, Layers._5)
            .mapping(5, Layers._6)
            .mapping(6, Layers._7)
            .mapping(7, Layers._8)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> STAIRS = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.EAST, Half.BOTTOM))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, Half.BOTTOM))
            .mapping(2, List.of(FacingDirectionHorizontal.SOUTH, Half.BOTTOM))
            .mapping(3, List.of(FacingDirectionHorizontal.NORTH, Half.BOTTOM))
            .mapping(4, List.of(FacingDirectionHorizontal.EAST, Half.TOP))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, Half.TOP))
            .mapping(6, List.of(FacingDirectionHorizontal.SOUTH, Half.TOP))
            .mapping(7, List.of(FacingDirectionHorizontal.NORTH, Half.TOP))
            .build();
    public static final TypeMapping<Integer, StructureBlockMode> STRUCTURE_BLOCK_MODE = new TypeMapping.Builder<Integer, StructureBlockMode>()
            .mapping(0, StructureBlockMode.SAVE)
            .mapping(1, StructureBlockMode.LOAD)
            .mapping(2, StructureBlockMode.CORNER)
            .mapping(3, StructureBlockMode.DATA)
            // Unsupported types
            .mapping(0, StructureBlockMode.INVALID)
            .mapping(0, StructureBlockMode.EXPORT)
            .build();
    public static final TypeMapping<Integer, FacingDirectionHorizontal> TORCH_DIRECTION = new TypeMapping.Builder<Integer, FacingDirectionHorizontal>()
            .mapping(1, FacingDirectionHorizontal.EAST)
            .mapping(2, FacingDirectionHorizontal.WEST)
            .mapping(3, FacingDirectionHorizontal.SOUTH)
            .mapping(4, FacingDirectionHorizontal.NORTH)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> TRAPDOOR = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(1, List.of(Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(4, List.of(Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(5, List.of(Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(8, List.of(Half.TOP, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(9, List.of(Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(10, List.of(Half.TOP, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(11, List.of(Half.TOP, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(12, List.of(Half.TOP, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(13, List.of(Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(14, List.of(Half.TOP, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(15, List.of(Half.TOP, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> TRIPWIRE = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(1, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(2, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(3, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(5, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(7, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(8, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(9, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(10, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(11, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(12, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(13, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> TRIPWIRE_HOOK = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(1, List.of(Bool.FALSE, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(2, List.of(Bool.FALSE, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(3, List.of(Bool.FALSE, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(4, List.of(Bool.FALSE, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(5, List.of(Bool.FALSE, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(7, List.of(Bool.FALSE, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(8, List.of(Bool.TRUE, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(9, List.of(Bool.TRUE, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(10, List.of(Bool.TRUE, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(11, List.of(Bool.TRUE, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(12, List.of(Bool.TRUE, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(13, List.of(Bool.TRUE, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(15, List.of(Bool.TRUE, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> UNPOWERED_COMPARATOR = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(1, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(2, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(3, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(4, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(5, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(6, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(7, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(8, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(9, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(10, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(11, List.of(ComparatorMode.COMPARE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(12, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(13, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(14, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(15, List.of(ComparatorMode.SUBTRACT, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> WALL_SKULL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(2, List.of(Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(3, List.of(Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(4, List.of(Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(5, List.of(Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(10, List.of(Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(11, List.of(Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(12, List.of(Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(13, List.of(Bool.TRUE, FacingDirectionHorizontal.EAST))
            .build();
}
